{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "#数据\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "#画图\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.读取图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "(55000, 784)\n",
      "(55000,)\n",
      "(5000, 784)\n",
      "(5000,)\n",
      "(10000, 784)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "#查看数据\n",
    "#详解 MNIST 数据集 https://www.cnblogs.com/xianhan/p/9145966.html\n",
    "#将 28 x 28 的像素展开为一个一维的行向量，每行 784 个值, 或者说每行就是代表了一张图片\n",
    "mnist = input_data.read_data_sets(\"./\")\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "#下载数据集，并用one_hot编码\n",
    "#mnist = input_data.read_data_sets('.',one_hot = True)\n",
    "mnist = input_data.read_data_sets(\"./\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#查看图片\n",
    "#定义图像的宽、高\n",
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4, idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(mnist.train.labels[idx]))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到images里面有数量不等的图片，每张图片是28x28长度的一个一维向量， 所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.训练网络"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 定义网络的输入\n",
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个float类型的变量用于设置学习率。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "#输入层\n",
    "x = tf.placeholder(\"float\", [None, 784])\n",
    "#标签\n",
    "y = tf.placeholder(\"int64\", [None])\n",
    "\n",
    "#学习率\n",
    "learning_rate = tf.placeholder(\"float\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "#权重初始化，从截断的正态分布输出随机值\n",
    "def initialize(shape,stddev=0.1):\n",
    "    return tf.truncated_normal(shape,stddev=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义了两层，一般两层网络可行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "#L1层\n",
    "L1_units_count = 1000\n",
    "\n",
    "W_1 = tf.Variable(initialize([784,L1_units_count]))\n",
    "b_1 = tf.Variable(initialize([L1_units_count]))\n",
    "\n",
    "#未经激活\n",
    "logits_1 = tf.matmul(x,W_1) + b_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "考虑激活函数的选择，尝试其他激活函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2 激活函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.relu激活\n",
    "output_1 = tf.nn.relu(logits_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.PReLU激活函数\n",
    "#output_1 = tf.nn.tanh(logits_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "准确率并没有提高多少"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "#加隐层L2层\n",
    "L2_units_count = 10\n",
    "\n",
    "W_2 = tf.Variable(initialize([L1_units_count,L2_units_count]))\n",
    "b_2 = tf.Variable(initialize([L2_units_count]))\n",
    "#未经激活\n",
    "logits_2 = tf.matmul(output_1,W_2) + b_2\n",
    "\n",
    "logits = logits_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2定义loss和用于优化网络的优化器\n",
    "loss计算使用了sparse_softmax_cross_entropy_with_logits, 这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为可以根据需要设定。\n",
    "优化器比较https://www.cnblogs.com/bigcome/p/10084220.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "#损失函数\n",
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.sparse_softmax_cross_entropy_with_logits(labels = y,logits = logits))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 增加正则项L2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "#l2_loss = tf.nn.l2_loss(W_1) + tf.nn.l2_loss(W_2)\n",
    "#total_loss = cross_entropy_loss + 4e-5*l2_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "增加L2正则后，准确率结果并没有得到提高。正则是为了防止过拟合而增加的，训练模型还未出现过拟合的情况。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 优化器\n",
    "\n",
    "#### 1.sgd优化器\n",
    "随机梯度下降算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "#optimizer = tf.train.GradientDescentOptimizer(\n",
    "#    learning_rate=learning_rate).minimize(cross_entropy_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.momentum优化器\n",
    "动量梯度下降算法\n",
    "一般有标准动量优化方法Momentum、NAG（Nesterov accelerated gradient）动量优化方法。\n",
    "NAG在Tensorflow中与Momentum合并在同一函数tf.train.MomentumOptimizer中，可以通过参数配置启用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "#optimizer = tf.train.MomentumOptimizer(\n",
    "#    learning_rate=learning_rate, momentum=0.9).minimize(cross_entropy_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.Adam优化器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer(\n",
    "    learning_rate=learning_rate).minimize(cross_entropy_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布， 要想看到概率分布，还需要做一下softmax。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 对比预测结果和标签，计算准确率\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "#dimension=1 按行找，tf.argmax()返回最大数值的下标\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), y)\n",
    "#tf.equal()返回的是布尔值，tf.cast转换成float32，tf.reduce_mean求平均值。\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 保存模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "\n",
    "#增加了trainig_step\n",
    "trainig_step = 5000\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "尝试改变batch_size和training_step的值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.656481, the validation accuracy is 0.911\n",
      "after 200 training steps, the loss is 0.159986, the validation accuracy is 0.9064\n",
      "after 300 training steps, the loss is 0.514858, the validation accuracy is 0.9296\n",
      "after 400 training steps, the loss is 0.170026, the validation accuracy is 0.936\n",
      "after 500 training steps, the loss is 0.227191, the validation accuracy is 0.9444\n",
      "after 600 training steps, the loss is 0.0637093, the validation accuracy is 0.9566\n",
      "after 700 training steps, the loss is 0.0282646, the validation accuracy is 0.9538\n",
      "after 800 training steps, the loss is 0.257175, the validation accuracy is 0.9644\n",
      "after 900 training steps, the loss is 0.0789426, the validation accuracy is 0.957\n",
      "after 1000 training steps, the loss is 0.273555, the validation accuracy is 0.965\n",
      "after 1100 training steps, the loss is 0.0488408, the validation accuracy is 0.9656\n",
      "after 1200 training steps, the loss is 0.252529, the validation accuracy is 0.9604\n",
      "after 1300 training steps, the loss is 0.270951, the validation accuracy is 0.96\n",
      "after 1400 training steps, the loss is 0.116737, the validation accuracy is 0.9654\n",
      "after 1500 training steps, the loss is 0.0401133, the validation accuracy is 0.9704\n",
      "after 1600 training steps, the loss is 0.00511358, the validation accuracy is 0.9724\n",
      "after 1700 training steps, the loss is 0.121237, the validation accuracy is 0.973\n",
      "after 1800 training steps, the loss is 0.0115174, the validation accuracy is 0.9718\n",
      "after 1900 training steps, the loss is 0.014686, the validation accuracy is 0.9712\n",
      "after 2000 training steps, the loss is 0.04967, the validation accuracy is 0.9738\n",
      "after 2100 training steps, the loss is 0.0178152, the validation accuracy is 0.9692\n",
      "after 2200 training steps, the loss is 0.200669, the validation accuracy is 0.9758\n",
      "after 2300 training steps, the loss is 0.0769269, the validation accuracy is 0.9736\n",
      "after 2400 training steps, the loss is 0.0452389, the validation accuracy is 0.975\n",
      "after 2500 training steps, the loss is 0.0758122, the validation accuracy is 0.9752\n",
      "after 2600 training steps, the loss is 0.306084, the validation accuracy is 0.974\n",
      "after 2700 training steps, the loss is 0.128167, the validation accuracy is 0.9708\n",
      "after 2800 training steps, the loss is 0.0121361, the validation accuracy is 0.976\n",
      "after 2900 training steps, the loss is 0.26536, the validation accuracy is 0.9782\n",
      "after 3000 training steps, the loss is 0.0108615, the validation accuracy is 0.9764\n",
      "after 3100 training steps, the loss is 0.0278585, the validation accuracy is 0.9726\n",
      "after 3200 training steps, the loss is 0.0379484, the validation accuracy is 0.9702\n",
      "after 3300 training steps, the loss is 0.0921315, the validation accuracy is 0.9766\n",
      "after 3400 training steps, the loss is 0.00828928, the validation accuracy is 0.9772\n",
      "after 3500 training steps, the loss is 0.0385691, the validation accuracy is 0.9748\n",
      "after 3600 training steps, the loss is 0.00635659, the validation accuracy is 0.9766\n",
      "after 3700 training steps, the loss is 0.0017977, the validation accuracy is 0.9802\n",
      "after 3800 training steps, the loss is 0.0281165, the validation accuracy is 0.9746\n",
      "after 3900 training steps, the loss is 0.0122462, the validation accuracy is 0.9776\n",
      "after 4000 training steps, the loss is 0.00982784, the validation accuracy is 0.9752\n",
      "after 4100 training steps, the loss is 0.0292744, the validation accuracy is 0.9754\n",
      "after 4200 training steps, the loss is 0.0874408, the validation accuracy is 0.979\n",
      "after 4300 training steps, the loss is 0.00550293, the validation accuracy is 0.9748\n",
      "after 4400 training steps, the loss is 0.00800723, the validation accuracy is 0.9794\n",
      "after 4500 training steps, the loss is 0.104071, the validation accuracy is 0.977\n",
      "after 4600 training steps, the loss is 0.00744845, the validation accuracy is 0.9776\n",
      "after 4700 training steps, the loss is 0.00895952, the validation accuracy is 0.9798\n",
      "after 4800 training steps, the loss is 0.00226192, the validation accuracy is 0.9778\n",
      "after 4900 training steps, the loss is 0.150756, the validation accuracy is 0.9748\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9758\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels}\n",
    "\n",
    "    lr = 0.001\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        #if trainig_step > 1000:\n",
    "        #    lr = 0.3\n",
    "        #if trainig_step >2000:\n",
    "        #    lr = 0.1\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss = sess.run(\n",
    "            [optimizer, cross_entropy_loss],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                learning_rate: lr\n",
    "            })\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 测试模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用我们训练的模型做一个测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-4900\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAd0AAAHiCAYAAACtERYWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XeYFEX6B/Dvu4ElLDlLWiQnUUFORQUURE8xY0IUz3CeWU88Ayrm8DuzoqIiKgYUFNOJAUVABAUElKgCIkFyDgvsvr8/ura7a5zend2Z6dllv5/n4eHtrZqa6qnuqemqDqKqICIiouRLS3UFiIiIygt2ukRERCFhp0tERBQSdrpEREQhYadLREQUEna6REREIWGnS0REFJIy1+mKyFAR2Ssi20WkSoyv+U1E9ojIqELyqIjsEJH7E1fb8InIVyKyW0SmpLousWKbFq6stSnbs3BlrT0BQERGmvZZFmP+1qb980Tk0oA8PUUk3+Q7IaEVDpGIZJl12Csi9xWVPyWdrqmg/1+eiDxdjCJGq2q2qu4w5X0aUd4eEfmpILOqtgDwQAzldlbV2331HC4ii8yGMSjKetwgIn+KyFYRGSEiWb60HBH5WkR2ishCEekd9Kam0UaYcv4UkRt9aU1EZJqIbBSRRyNe96mIdPX/TVWPBXBFDOuaMKb+L4vI7yKyTURmi8iJxSwmsk0Hi8jPprylIjLYn5ltmlwicrWIzBCRXBEZWYIiItuzl/nstkT74mZ7Jp+I1BKR98X54fK7iJxfzCIeUdUcX3mBn4mqLlbVbACTiyhzldlOxpsyG4rIhyKySpwfWTn+zIW9p0k/zrTlTtO2zYLeuLD2N+UsNe9xru/vNURklohU9a1rrlnXN4pYVwAp6nTNh5xtKtoAwC4A78ZR3okRZU6NpzyfOQCuBDArMkFE+gK4BcBxAJoBOBDA3b4sbwH4EUBtALcDGCMidQPeZyiAVqacXgBuFu+X360AXgXQHMBpBTuwiJwDYKmqzohj/RIlA8AfAHoAqA5gCIB3IneYYhIAFwKoCeAEAFf7N/44sE1jswrAfQBGJKi8HaaswUVlLCa2Z+yeBbAHQH0AAwA8JyId4ihvKII/k5LKBzAewJnFfU8RqQPgPQB3AKgFYAaA0YW8V2Ht/wSAfgD6AhgmIunm7w8CeEhVt5Vk5QAAqprSfwAuArAEgMSYfyiAUYWk5wDIA5BTzNcpgJYBaVMADIr425sAHvAtHwfgTxO3BpALoKovfTKAKwLKXwXgeN/yvQDeNvGnANqY+G0AZwOoZjaWGgHlDQIwJcXtOhfAmYloU5PnKQBPs01Db8f7AIws5msC2wVAbwDLSrIdsD3jascqcDrc1r6/vQ6nA4nl9SMB3BfrZ+L720QAlwaU2RPAioC0DNPeOcVoh8sBTI1Y510A2kYpv9D2B7DE9/c/AdQD0A3A+OJ8RtH+lYY53YsAvKam1gAgIptF5KgSlnchgMmquiwRlStEBzi/sgvMAVBfRGqbtCVq/xqaY/5uEZGaABpGKasg788A+ohIDQBdAMyDs6E9oaqbE7QuCSUi9eFs1PN8fytxm4qIADjaX16SsE1jFOc+Gha2p6c1gH2qutj3N3cdRKSpadOmsRQWw2eScDG8p9Xe6kxt/BZQp6Laf62IdBaRznCOvjcBeBLAtfGuR0o7XTPe3gPO0IxLVWuoaklPMrgQzi+OZMsGsMW3XBBXjZJWkF4Vf5Ud8frIvA/C6XC+ATAMQAUABwH4SETeFJFJInJ1SVci0UQkE87cxququrDg73G26VA42+or8dewUGzTGMXZnmFhe3qyAWyN+Ju7Dqq63LTp8mKUV1DGX8pLkqLes7htWljeK+B0ssMBDATwLwBfAqgoIp+ZueAeJVmJjJK8KIEGwhliWZqIwswv7wYAxhSR71M4OwkA/FNVY5oAj7AdzhBSgYJ4W5S0gvRo8wDbfem7I/Oq6kYA55h6pwGYBGeDuAXOL+xBAGaJyARVXVCC9UgYU7/X4QxjJeRLxnxZXQjgaFXNLSQf23Q/wvZMuOKsb6zlFZTxl88kGhHZ7ltsn4T3LG6bBuZV1dlwhr8hIg0BPArgCDg/rK6HM8w9SUSa+UdpY5Hq4eULEXGUG6eLALynqtsLy6T2iVcl2ZkBZwips2+5M4A1qrrBpB3oP8PNpP9leFRVNwFYHaWsaEOplwOYpqo/A+gEYIaq7gHwk1lOGTME/DKckzTOVNW9CSjzHzAnwqjqisLysk33L2zPhFsMIENEWvn+FrQORSrmZ1Lwmmzfv1iPqIvznlZ7i3O5WouAOsXc/gAeBzBEVXfBa9NlADIBBJ14Fyhlna6IHAmgERJzljFEpBKcExhGJqI8U2YFEakI50zaTBGpaH7JAsBrAC4RkfZmLmdIwXubeZPZAO4yrzkdznDT2IC3eg3AEBGpKSJtAVwWuR4iUg/AVXCGWgFgKYBeIpINoCuck9FS6TkA7QD0MxtnXERkAJxLSPqoasLWjW0aGxHJMJ9TOoB0s84lHhkTkTRTXqazKBVFpEIC6sn2jIGZ33wPwD0iUkVEugM4Fc7IVEkV+ZmUhGnPgku7ssxyLO/5PoCOInKmec2dAOb6p7kKxNr+ItIHQEVV/dj8aSmAY8U56zsLwIZir2BRZ1ol6x+AFwC8HpC2Hc5wYrS0oYhyhiOA8wD8joCzoINe50v/y5mRcM6804h/PX3pNwJYA2eu5BUAWb60HPP6XQAWAejtSxsAYJ5vOQvO5RRbTXk3RqnfawD6+5abAJgOZ4L/sYi8gxDumZHNzGez27Rdwb8BJW1TOBv33ojynmebhtamQ6N8TkPjaM+eUcqbyPYMpz3Ne9YCMA7O5VvLAZzvS2tq2rRpwGtH4q9nL8fymUxEMc9ejtKeGut7wjk7fqFp04nwnf0M4Hn4vkMKa3/fe80G0Mz3t+MALINzxH1uUZ9R1PUOs9ETtOEMMRvNZgBVYnzNIrNBjSgkz244E+n3pnod4/x8voAzLzEh1XVhm5bPNmV77l/taer8ommf32LM38q0/05EXMrly3OM6fA2A+ib6nWM47PJMuuwA8BdReUX8yIiIiJKslSfSEVERFRusNMlIiIKCTtdIiKikIR6c4w+af05gZwiX+S/K4kuk+2ZOsloT4BtmkrcR/cvQe3JI10iIqKQsNMlIiIKCTtdIiKikLDTJSIiCgk7XSIiopCw0yUiIgoJO10iIqKQsNMlIiIKSag3xyBKhmX3HeHGeRXtewHU7bDOjb/rHPSoVKDFVxe7cdXvK1lp9Z+aGm8ViYgA8EiXiIgoNOx0iYiIQsJOl4iIKCSc06UyadMnrdz454Ofiek1ewu59fvCXi+58RtdG1pp73zRw43zFvwSYw2pNJEuHazlTz583Y07PX+1Gze5l/P3YUuvUd2NFz1zoBv790kAGLK2ixv/NKC1lZY3f3GSapd4PNIlIiIKCTtdIiKikHB4mcoE/3AyAHx78Nsxve75zd5w1WPf9XHjnGbrrHyft3/PjQdUXW2l3T+ojhsf+B8OL5dFaw+rZi3vQ54bV17FR86mUn7zxm78U88X3DhyOui+ejPduPPpR1ppTTi8TERERJHY6RIREYWEw8tUau07zjtb8avOz0akZrrRE5u8Mxm/PqernW3VWjdsvWmGG6dVrGhle2B6Jze+rc5Pdj1q7ou5zlQ6bTooz1pesS/XjWu//F3Y1SnXMpo0tpabD/81RTVJDR7pEhERhYSdLhERUUjY6RIREYWkTM/pbrjsCGu56UBvbmDh2vpW2p5cbw6w0VteXHnFditf/uz5iawixWF7owpunBbx+9A/jzvxFG8+Nm/JopjK/vXuQ6zlN2s96lvKstIaj+dv07JIux/sxpNPfsxK6zHpGjduiR9Dq1N5tfxO7xKfLifY37GPNJxc7PKyj7Qv+fvjDq/8OnO9czAqffB9sctONn6bEBERhYSdLhERUUjK9PDyzYPftJbPrLLJW2hRyAt7euGyfTutpCfX9Yq/YjH6fm0zN67yaHUrLWPCzMjs5U6N17xLOc6acYGVJpu2uvG+1cuKXfalf//SWs5OywrISWXVxvaV3LhhemUrrdGYzMjslERz//m0G+/VvEJyxmZi5zfsP3T2wvd3eA8sGbHtNCtbxlep/17lkS4REVFI2OkSERGFhJ0uERFRSMr0nO5Tt51rLd95kPcbouYC+xEVm9qJG1c4aLMbP9LxPSvf4w2nu/EnO7Pd+KTK9qVFhdmle9x4em4VN+5Zca+d0fdeLc/5p5XUekLMb1cuJOIh1cvu9y4xu6TGfyNSvdtC/nv14VZK1S8XePWIuxYUluOu9M4JGLejhpWWPdG7tIxtmhyZE7251UxJj7u8H/fku/GyvXWttNOrbHTjs7O9W7+e/fpwK9/Jjbog1XikS0REFBJ2ukRERCEp08PLVcZMj1gOzlst4O9PN+hpLd/XPcd7zTfeHa4e6dky5npl7PKGQarM9R6IXnvSWCtfpwq+O2Mt4yUMybB5oDek/O2F3pBy9TT7KUPf5XrDX7Pvs+9WVWlr6burDf1Veoc21vID9d5y45e32k+2ydu8JZQ6lSe7TutmLV/c8F039l8mFOslQx0nXGEt153gXdaXtcUu49ae3vHjT/2fCixzxa3enasaPzg1pnokGo90iYiIQsJOl4iIKCRleng5Efb9ucZarjLWW/YPYFQZs6FE5a+51Bve7FDB/rj/u9EbDst5ZYldrxK9G0Vaf6h3FnvkkLLfRRMvdePW4zicXBat7FM7MG3mtmYRf9mV3MqUE/4h/fses88U7lphjz9nYBn+O0gN+fpMN25380IrX97WrQjS5hfvASjfn+Lt592ydlv5Pv3XI258fMWbrbScB7y7VWlubuB7xYtHukRERCFhp0tERBQSdrpEREQhKfdzusmQ0ayJGz9z2zNuHHlXlnef7O3GtVd/B4rfni/subvv2vofTu/N9XT+7iIrX7t//+bGvENR2bS1/d7AtNnPHGwt1wD3t0TI952nYs/hBvvH7ydYy9vO8Z4G1XqFdz5FcfZD/x3rrhzpXWo0459PWPkapnvvNesSO+3M97zvBJ2zAMnCI10iIqKQsNMlIiIKCYeXk2DhDY3c+LAs70EL8/bYlynUmr8ztDrtzzIOzHHje1u+a6XV9F0mNNN3FUCze+3Bq7xNm5JSN0qu3BMPc+MPjn/aSrtnvXdz+1pj51pp+aAw3bamqxtvvdS+tCtvxS8Jfa+csevd+I7T7IeXPNTgh4S+V0nwSJeIiCgk7HSJiIhCwuHlBMg96TBredZZj/uWvJt0/+u666x8labyzkeJ0OKdlW58SIXg35Hn+W6g3npO6oeZKH4rjvW+wg6qYN9x7KJlndy43g777kaUeIU9M3fuof7nmyd2OPkvxJvSy0izJxIKq+Oqu724wWkJr5WLR7pEREQhYadLREQUEna6REREIeGcbgIsP9H+7ZIt3jzueUv7uHHl8XOsfAoqqU0XeU9vuru+/65TWVa+i5Z5d/1qd/Ovbsy7Tu0f6nZc68Z5as/fZXxQM+zqlDuL/lXZjWN9OH2yLTvDuyRpTF37vJm9mu6L7foecJcXJ/OSMh7pEhERhYSdLhERUUg4vFxCaVWruvHAo6dYaVvzvQcnr33gQDfOyuVlKiWV0egAa/noa6e7cXZaVmR213fzW7px6038/PcHGc29h1r8t413B7IXtzSx8tUawYcaJNuQoz9KyftmNGlsLW/r4n0/PH/xsJjK+D7XvsRM9uyLv2Ix4JEuERFRSNjpEhERhYSdLhERUUg4p1tCvwzt4MYf17HnEE795Uw3zvof5xETYcFt9nzduAbR55J6/dTfWuZlQvufX/7pzd8d7pvOv2xWLytfE/wcVpUoZPPvbmAtzzv+mZheN3Z7HTd+7ib7u6LignBuy8sjXSIiopCw0yUiIgoJh5djtOUC+2HIc895yo1/27fXStv+sHc6exZWJ7di5cTMUx6P+Ev0y4SqX2nfS2YfH06/38lvsjvq33dtrhj177R/yJzY0I0fbDi2RGWMXHmkG1f8KDVPeeORLhERUUjY6RIREYWEw8uF8N8F6fo7RltpWeJ9dOfOGWil1f2UZyynyt761a3lzD2Nil1G3rr11rLm5rqxZHnD2ul16yBIXt0a1vIv/64Q03trnvcA7rbX/Gql5W3dGlMZ+7thfxsV9e+NPg1+QDklR7p40zmFPSB+6/mHB6bdfc/LbtyrUvSpg8jy//pwhdjaXo9dGVO+ZOKRLhERUUjY6RIREYWEnS4REVFIOKcbQTK8j6TzxyvcuH/2BivfG9vquXH9O+zfLsl8ADIV7pMxI+Iu48gfz7OW16+p5sY1625z4+ld3oz7vQrTfsjV1vKBN5fPp+bs7tfNWj6qov9SD36FpdJDo89y47MveSIw36T/e9aNC3vY/V6N7X0LK8Ov44QrrOVWmBXbGyQRj3SJiIhCwk6XiIgoJBybidS5jRveW+/1wGzPPuDdLLvGnPI57BemU+cPsJYndByTtPeaeshbJXrdTt3jxns1eJLh73MHufGW2cGXHTWaEs5DtUu75afYY47+y/XuWd/JjbM/mGnli3GkkuJw4Gjv8rrvL7DvCNYtK/jyn3hFPoB++J893HjTld7DENoujbjsLmk1ih2PdImIiELCTpeIiCgk7HSJiIhCUu7ndNPbt7aWL3/7g6j52o+4ylrOeX1a0upEf1Wp71JrucMD3uU0GuNWXLXtRjcuzuU+HSZf7L3X8iqB+Q4cs91b+P6nwHw18UvUmDzp1bzLtP7T/X+B+d789Bg3PnAfz60IW978xW58542XWml/9PPOa1h84gsJfd8rR9iXAjW5f6pvqXQ/WYxHukRERCFhp0tERBSScj+8vPDKmtZyv8rRn+TSeOIe+w/KCxJSqflt8Q0lnowusb8X5sb1XlR8+b4nO83feYCV1ntlVzdu9cA8Ny4Nl4OUZ5U+sB8K39o3U3fMed70XOagNVa+8R28J7gd//O5bpw/sp6VT70HcCFn9jorrSy1PY90iYiIQsJOl4iIKCTlcnjZfwP1Cf0ejUitHG5liOgv1De8vKirnVYBv7txWRpWLM+qveW72iPihm+nw/s+roIlvpQlCFKW251HukRERCFhp0tERBQSdrpEREQhKZdzuqu6p7tx04zgOVz/g+ozt9qXDPGCISIiKi4e6RIREYWEnS4REVFIyuXwcmEe3NDejb/rm+PGujr4BvZERESx4JEuERFRSNjpEhERhYSdLhERUUjK5Zzugbd4T6j5+y2HFpLzz+RXhoiIyg0e6RIREYWEnS4REVFIRPkwdiIiolDwSJeIiCgk7HSJiIhCwk6XiIgoJOx0iYiIQlLmOl0RGSkie0RkWYz5W4vIdhHJE5FLA/L0FJF8k++EhFY4RCKSZdZhr4jcl+r6xEpEhpo6bxeRKjG+5jezHYwqJI+KyA4RuT9xtQ2fiHwlIrtFZEqq61IS5X2fFZHepp75ItI71fWJV3nfX2PZPguT0k5XRFqZL5PAhgjwiKrmRCmvlois8385qepiVc0GMLmIMleparaqjjdlNRSRD0VkldkYrPczHdwIEdkqIn+KyI0R6ceJyEIR2SkiX4tIs6A3FpEck2eneU3viHKWmvc41/f3GiIyS0Sq+tY116zrG0Wsa8KJyNUiMkNEckVkZAmKGG0+/x2mvF7mM9kS7ctaVVsAeCCGcjur6u2+eg4XkUXmC3BQlPW4wXzWW037ZvnSAtspSjmB24eINBGRaSKyUUQejXjdpyLSNWJdjwVwRQzrmnSlfJ8VEbldRJabz/1tEanme69GIvKB+dxXiEjgZxrD/j9YRNaLyDwR6eT7e3cRGefPq6pfmvVZXsT6hEZE2onzY26LiPwqIqcXs4jI/bWGiLwqImvNv6H+zHHsr/1E5GfTyU0Vkfa+tCwRedy00SYRGSYimYWsc0Gnvt38e8mXdr6IrBaRZSLSy/f3FuZ93YewF2P7jCrVR7rPAvghgeU9DGBBgsrKBzAewJkB6UMBtALQDEAvADeL+cUtInUAvAfgDgC1AMwAMLqQ93oLwI8AagO4HcAYEalr0p4A0A9AXwDDfI3/IICHVHVbSVYuCVYBuA/AiASVt8OUNThB5RWYA+BKALMiE0SkL4BbABwHp10PBHC3L0th7RRpKAK2DwC3AngVQHMApxV0siJyDoClqjojjvVLttK8z14IYCCA7gAOAFAJwNO+9FEAlgKoD+AkAA/4v2AjBO7/ItIQwCVwto/n4OyLEJEMAI8CuD4B65I0pp4fAPgYzvfT5QBGiUjrOIp9HEBlADkAugEYKCIXx1nPVnAOIK4AUAPARwA+NPUHnH21K4COAFoDOBTAkCKK7Wx+LGSr6qXmfTIAPGRefzXsbeYpADeoal486+KXsk7XHLVtBjAhQeUdCefDfyUR5anqGlUdhuAvmIsA3Kuqm1R1AYAXAQwyaWcAmKeq76rqbjhfwJ1FpG2UehdsLHep6i5VHQvgJ3g7exVV/VlV5wDYA6C2iHQD0FxV30nEuiaCqr6nquMAbEhQed+r6usAliSiPF+5z6rqBAC7oyRfBOBlVZ2nqpsA3AvTpjG0U7SygraP5gC+UtUtcLavA80R2S0AbkvAaiZFad9n4fw4fVlV/1DV7XA69HNEpLKIZAPoCeB+Vd1r9qcxAP4RraAi9v+mAH5U1a0AvoTT+QJOZ/uhqi5L0PokS1s4P0oeV9U8Vf0KwLdwfrCUVD84oxk7zfq/jIDPthj6ApisqlNUdR+c9mwEoIfvPZ9S1Y2qug5OB1mS96wNYKWqroavPUXkLPP36XGuhyUlna75grkHwI1R0pqKyGYRaVqM8tIBPAPnV0rS7/YhIjUBNIRz1FRgDoAOJu7gTzNDML/50v06AFgSccTqL2utiHQWkc5wfn1vAvAkgGsTsCqhMW16VKrrUQSr3UxcX0Rqo+h2csWwffwMoI+I1ADQBcA8OB38E6q6OUHrklBlaJ+ViDgLzoiDBKR3LMF7/Aqgk2m/3gDmiUgTAOcC+G8JyisNrM+ihPtrIj7bosqMLDcyvbGIVC+kvElmuuc935TBOjgHM40B9IHTnlXhHDXfGmf9/yJVR7r3wvlFuiIyQVWXq2oNVS3O/Me1AKar6syE1bBw2eb/Lb6/bQFQ1Ze+BTZ/emRZheW9Ak4nOxzOL9F/wfk1VlFEPhNnjrEHSjnTpqX9RKDItiiIq0ZJK0gPalP/6yPzPgjgaADfABgGoAKAgwB8JCJvisgkEbm6pCuRJGVhnx0P4FJx5t6rA/iP+Xtl82PpWwB3iEhFETkUzihF5eK+iapuAHA/gK/gDFPfBGcf/Q+A00XkGzN33Dj+VUqKRQDWAhgsIpkicjyco0f3syjB/joewC0iUlVEWsI54iz2ZxvhSwA9xDlprgKcUaAKvnLHA7hOROqKSAN4ByJB79sDzvB3WzjTYR+LSIaq5sP5Xh0Dpy0vgzOt9DSAg8x37GcikogfEeE/ZUhEDobz6/CQBJV3AJwPu0sxXrPdt9g+MGOwgtdXgzdMWQ3ANl96tYjX+NMjywrMq6qz4QyLFcwlPQrgCDhf2NfD2XgmiUgzLcf39BSRT+F0ZADwT1UtyclkkW1REG+LklaQHtSmBel/2T5UdSOAc0y90wBMgvPj6hY4R8GDAMwSkQlmaDqlytA+OwJAEwAT4Xy3PQpnCLLgh8IAOHPSf8CZthiF6KNPRVLVt+DM8UNETgKQC2e+v2BE4xQ4R73nBpWRKqq6V0ROg9Op/AfOOSfvwFmHkrrWlPcLnCmmtwCcF5Q5lv1VVReKyEVwRkQawmmv+fDa8344c72zTd1fhLONron2nqo6yYR7ROQ6AFsBtAPwk5lymmDq1hnOXPFgAMsAHAVnu3oJwOGFfwxFS8Wj/XrC+bWxXEQA56ggXUTaq2phz9kL0g1Og8w35VUCUElE/gTQKNoEuDnzzCUiB0bmKYyqbhKR1QA6A/jC/LkznGFCmP8v8pVfBUALX7rfPDhzelV9Q5edAbwZJe/jAIao6i5xzpicoap7zBl7deH8ei2XVPXEBBQzD85nXzBX3hnAGlXdICIxt1MM24ff5QCmqerPpk0fN236E4BOSNxJRvHoiTKwz5ojlrvMP5gjuJXmH1T1dwAn+8p4E8D3Jai/vx6V4JyVeyKcYew/VHWriPyAUjw/r6pz4c2NQkSmwjm5r6TlbYTzo6agvAdQyGcb6/6qqmPgHIHCDOdfAjPPrqq74ExPXG3SLwcw02wHMRUPe3ga4myQzwC4BkAdAOmq+rvZNg+KsdxCpWJ4eTicDuhg8+95AJ/AmTQviU/hfCEUlHcnnF+cB8d7xpmIVIQzJwQAWWa5wGsAhohITXOC1GUARpq09wF0FJEzzWvuBDBXVRdGvoeqLobzS+0uM+x1OpzGHRtRlz4AKqrqx+ZPSwEcKyIdTB0TcgJTSYlIhlnXdDhfyBXFO8uwJOWlmfIynUWpaIaY4q1nBVOuAMg05RbsB68BuERE2psdfAhMm8baTj6FbR8FdakH4Co4J9oBTpv2Euekn65I8ElkcSgT+6w4lx+1EEd7AI8BuKfgS1icy2Sqmm3gAgDHmzxB5RW2/xcYAmCkqq6Cc0lQGxGpD+eM9dLSfn8hIgeZ7biyiNwE50fQyDjKayEitUUkXUROhPNjMu57BYhIF1NmXTjb4YcF36PiXAJ2gGnvw+FcLXJXQDkdRORgU1Y2nFGQlfjrj9pLAcwyI4wb4PwYbI9EtqeqpvQfnC+cUb7lpnCG55oG5B8J4L5CyhsEYEqUv08EcGnAa3oCWBHl7xr5z5eWBWc4ayuc4YwbI17bG8BCALvMe+f40p4H8LxvOcfk2QVnvqV3RFlZcL7wm/n+dhycoY/VAM4tzmeUxHaM/LyG+tK3Azg6lm3A1yaR5U0s6nVR2q9llO0gstyevvQbTXtuhXNWbVYs7QTnV/68WLcPk+c1AP19y00ATIdzstxjsWzXqfgX+bmjlOyzcC4bWQRgJ4DfIz9zONMx6+BcjjYFQNeIdGsbjbKdaET+tnCOutISGSGyAAAgAElEQVR9fxsMYD2cYdBOEfmXIWLfTmEb/p/ZzrbD+REUuZ8Ud389G85U104431V9Y3ldRHq0/XUKnGmZjQBegHM1R0HaMeYz3WnafUDEaz8FcJuJjzV5dsAZERwHoFVE/jpwpneq+f42AMCf5n16xbp9FvrZp7rxS7CxvGg2iN9izN8KzmUOOwEMCshzDJwv0s3RNpay8g/OF/1ms2Hdler6FKPeQ0ydN/t3qiJes8hsByMKybMbzglM96Z6HeP8fL4wXzwTUl2XEta/XO+zcH4gbzb17ZXq+iRgfcr1/hrL9lnYPz5Pl4iIKCSpviMVERFRucFOl4iIKCShXjLUJ60/x7JT5Iv8d6XoXMXD9kydZLQnwDZNJe6j+5eg9uSRLhERUUjY6RIREYWEnS4REVFI2OkSERGFhJ0uERFRSNjpEhERhYSdLhERUUjY6RIREYWEnS4REVFI2OkSERGFhJ0uERFRSNjpEhERhYSdLhERUUjY6RIREYWEnS4REVFI2OkSERGFJNSH2JcWeb0OdeOrh79jpT3XqmXS3nfbOYdbyzVmr/fqtOjXpL0vFc/mC4+wlqc/9Jwbt3/2Sjdu+vD3Vj7dty+5FdvPZTRr4sb1Rm92429mtrfytR3mpeXNW5T8ihnpdetayxtO9L4rao6e5caamxtanajs4ZEuERFRSNjpEhERhaRcDi//3jfLjWulbw/tff88aY+1vHeg95un1smhVYOiyGh0gBvfe+dLgfnmXzXMjU986mgrTbdtS3zF9mMZDepby/dMHOvGbTLz3fjYDQ2sfHnzfkluxXz8Q8oDpsyy0g6v+L4bX/XTP72EH+clvV5lWXqd2tbyosebunHPVl7bruyx18q3vwzb80iXiIgoJOx0iYiIQsJOl4iIKCTlZk5XMiu48bHHzk5JHar+WNFaPvuSb9z46xqNrbS8zVtCqRM51vZt5sbHV94bmO/QGee4cd3ti5Nap/1RRuNGblx99E4r7aAK6W7c5ssr3LjVRfZcapgW3Jfjxmdnj7fSDn3iZjc+4MepYVWpTFp79ZFufNd1r1lpJ1X+POprTqvTz1ret3JV4iuWAjzSJSIiCgk7XSIiopCUm+Hlbad7d6F6qtHTbtxu3NVWvlaYnrQ65NZUa/namgvdeGLVdnZmDi8nVVrlytZy32unxPS6rLdreguqwRkpqk3dvbtOjct5NjBfuyFr3TjM+3zpEZ2t5V9PfsGNe/zU30prMsLbf/OSW60yKb11Czd+6d9PuPHBFexuJx/RrX6uqrXc8J/epWP7Vv8ZfwVThEe6REREIWGnS0REFBJ2ukRERCHZb+d0tfvB1vKzDz/pxqO2epeHtB1iX/aRzLmZI47/OYmlU3HkHmnPod9X7+XAvDvzvdt3VntzWtLqtD/yPzkIANadujswb9f/XuPGDf4I7xIc/zzukDdeDcy3/RP7dpRVNixJWp32Bwtu8c5/8F8OFqvpXd60lhd/5+2HZ7x+o5V24P0/unH+7uBtrDTgkS4REVFI2OkSERGFZL8dXt50q323m8YZ3oUHN15zkhtnbpqZ1HpkNPSGpF5pat/RZq/yN0+qLD0j9uGus345zbe0f9wVJyx/PJltLf/SbaQbD1lrTwE1esV7Ok+Yl+Cs7FnFjbtn2RewdJx6kRs3fZp3nSpMevvW1vKXxz3hW6rkRg9vsKd2Zmz2njI0uoX9HenX2ndXwRcHPGelPTziVDfOX/p7TPVNFX7rExERhYSdLhERUUj2q+HlDZcd4cbvdvo/K+21LQe5ceaXyR1S9pt/j3f25l61B80uWtbbjfPWrgutTgScdNicwLQt+bus5b1DvYetp3F4uVhUxVr27wPTN+RYaem71iJZ0qradzdadH97Nx53ymNunI9MK1/T/j8lrU77m/Xd7IfT52R4d327/I9j3HjF4dutfGlVvKnALld4Z7DfdNk7Vr4BVb3t4xj72TH4aOxyN55/Uum+cxWPdImIiELCTpeIiCgk7HSJiIhCsl/N6aadtt6ND8jIstJefvMEN26M5J76n96hjRuPOs57Skmu2g9HX/6Yd4p9ldzkPd2IHLl/P8yNn2n0YmC+FRGPtUn75sfoGSku/2s7zlq+ZGIvN16+raEb73nZvhNUrP482nsK1N//NttK+/CAYb4lbx63++xzrXw18UuJ3rs8yrO/cpEP7/Of+0InN66F7+x8O3a4ccNHve/md/odZuU7r+rH3oLal3atyfXm7HV3buyVTgEe6RIREYWEnS4REVFIyvTwcnrdutbykNafBOZt/EB4d5NZeGUNN+6a5V0i8eym9la+KmM5pBymNYdlFp0JQL+Pr7eWW4HtVFL1nq5kLX893LvWo1cl+8b0Lzf92o3T4F1qlP+YoiSsMhBcxlvbvEvCat8W2wPW6a+qnrk6MG1LX28IudYrsZV3Z7MPI/4SfIw4+ce2btx60/exvUGK8EiXiIgoJOx0iYiIQlKmh5elsn1bkr6Vt7hxtx8utNIaYEEodQKAOjkbo/79jaVd7XxYHDUfJUeFQzYFpi3Y490Vp+1T6620MG++v7/J+Mq++9uTRx3rxvcemWOlrTjeGwL+td/zbvx9rn1Xqws+vyKm9271mncW6yfvjgjM98j8vm7caM68wHxUuG1jG9p/6OCFg9p7UzSTDutmZVt3iPdQDD3Z++7smGkPEy/Y61390cH38AMAeP/Ep934P4df5iVMm1t0xUPGI10iIqKQsNMlIiIKCTtdIiKikJTpOd38jZut5XvXHerG57eYYaVNatjCjRP95ImMZk2s5W8Pftu35P2u2TWtTsQrOaebbLtP9uaPZhzmf/C1/RD7RXvruXHe4t+SXa1ya9+fa9y48ntrrLTW73nx3684FEFaI7ZLQtIO8i4j8V8+BAD3re/oxs2u884FibgZGRVDgw+XWsuLb93jxoNrz3fj/4yzz68JupzrnN9OspZ3XetdInr6WxOttIur/eHGv13rfee2mFZEpVOAR7pEREQhYadLREQUkrI9vLxtm7X8+UpvOGnywW9aaas/ru6lvXAEimtze3sIJDvHG5I6/IBldr0C7mMjJbuxDsVhVx1vGDlT0gPz3TzzDDdujtJ3mQEV3/K7vPaOHML8/H7voerZf5TCMcgyKHLa7vLB3p3dXvnvY27cOrOK/ULfwwtafu5d7tP26oVWtvwd3hD1Q1/1s9IuOc2bOnq4qzdP8VJne4g6f054l44G4ZEuERFRSNjpEhERhYSdLhERUUjK9JxupJp3e7eF7DH0PCvt/Y4j3fjhu+yHKMdiRq49H5jn+73StcKeiNyCaJo+/ZO1zCeYJF/uaZuj/t1/20cAaPxSbE8gotJr/eX2uRpzD3/WjZft22WlVVoXuc9SomW/69368WLc6MYbz7b3vd1bsty43WDvcr0838PtI7W5Zb61fFwr75yMLzqMdeO77rKPKxudgZTjkS4REVFI2OkSERGFZL8aXsb33vBt9b/bSQN7XuvGm1tlobhqvxg8JL3yvQ7W8sy/jYyaL/ISJ0q89NYtrOUZh43yp7rRp9s7Wvkyv7SfhkNlz84+2wPTzpp9qbVc7+tZya4O+fiHmrPfDc4X6xO9Ir9Lt77v2599X8cPHzTWyjesYU83TvSdCWPFI10iIqKQsNMlIiIKyf41vFyI9InecFLtiYkte9eyqvYf/hY9n3Y/2FqWb2cntiKENb3qWctBd6F65us+1nIrTI+aj8qOF7q8bi2vzvPOkq39ROWwq0MhqvuC9xCMv514vhtP72LfmfC6m3LcuMW/ObxMRES0X2OnS0REFBJ2ukRERCEpN3O6SRVxA6q0gN8ynMNNvt21ot8NDABm5np3IWr38AorjQ8vL5tW3HqkG3fPsi8DmpbrzeOm8xKh/Vu+d7FR7Ue9dl//un0nsgXnencp6/fmhVaazpyXpMrZeKRLREQUEna6REREIeHwciJEPJw+6CH2lHz1jl0ZmPbh1kPcOG/d+jCqQ0k24LwJbhz5oPpLZgxy42awHzaSXruWt1CvthvmLfglsRWk0KV986Mb93x1sJU2/x/e8PK2++2h52r9vUs/k3n3QB7pEhERhYSdLhERUUjY6RIREYWEc7oJkF8xeA53XV5uiDUpnyTLe2rUqQfMCcy3YU+2G2su22V/l5/nHVOsvfpIK+2kSye78bglDd24NDzknBKn5fA/rOXX+zdw40mdxlhpJ3T+hxunTUne5Z080iUiIgoJO10iIqKQcHg5AUad8Ly1vGCPN9x83sib3bgppoZWp3Ilz7sbzfAFR1lJ1x+5zI0n/tHSjRshnLvPUOosOOYVN84/xr6cqMMkbyix5dAdbhzrQ9SpbNj3h33nuXdO7+HGA78cbaWtH7zbjetNSV6deKRLREQUEna6REREIeHwcgLcs/QUa3nHsEZu3HQsh5STTfd5jyvIuWWHldbuwYFuLLOrgvYvn93uDRfOv7Whlfbd9LZu3PbJVVZaiz8XuXHe7t2g8sF/x7FzlhxvpX10yEtufMnhV3oJ0+YmtA480iUiIgoJO10iIqKQsNMlIiIKCed0E+E4+7T0KlgRkJGSLe/XpdZy0/4pqgiFouJH37vxuo/stJaY5sb7QGTbebp9Gdn0qQe48aY2Vdy45jQkFI90iYiIQsJOl4iIKCQcXiYionInb/0Ga3l46wPduCa+S9r78kiXiIgoJOx0iYiIQsJOl4iIKCTsdImIiELCTpeIiCgk7HSJiIhCIqpadC4iIiKKG490iYiIQsJOl4iIKCTsdImIiEJS5jtdERkpIntEZFmM+VuLyHYRyRORSwPy9BSRfJPvhIRWOMFEpLepZ76I9E51feIlIkNFZK9ZpypFvwIQkd/MNjCqkDwqIjtE5P7E1TY5ROQrEdktIlNSXZeSKO/7ZGFEJMusw14RuS/V9YkV98vCFWefLRWdrohMNBXebv4tKmYRj6hqjq+8gp1+u+9fOgCo6mJVzQYwuYgyV6lqtqqON2WKiNwuIstFZKuIvC0i1Xzv2UhEPhCRjSKyQkSuKGR9iyprsIisF5F5ItLJ9/fuIjLOX5aqfmnWZ3lsH1XyiUg7sxFuEZFfReT0YhYx2nz2O0x5NUTkVRFZa/4N9WdW1RYAHoih3M6qeruvnv1E5GezfUwVkfa+NBGR+0RkpVmPiSLSoZB1PlhEJpu8K0TkDl9aExGZZraNRyNe96mIdI1Yn2MBBG4/YRCRWiLyvvlC/F1Ezi9mEZH7ZJaIjDDb+58icmNBWhz7ZEMR+VBEVpkv7xx/5sLe06QfJyILRWSniHwtIs2C3lhEckyeneY1vSPKWWre41zf32uIyCwRqepb11yzrm8Usa5JISLnisgC066/icjRxXi5tV+a8g4VkUlmH1ojItcVpMWxXw4XkUXi/MgaFGUdbjCf9VbTvlm+tMB2ilJO4PaRzH22VHS6xtWmQbNVtU0CynvEV162qubFWd6FAAYC6A7gAACVADztSx8FYCmA+gBOAvCAiPQqblki0hDAJQAOBPAcgAfN3zMAPArg+jjXI6lMPT8A8DGAWgAuBzBKRFrHUezjACoDyAHQDcBAEbk4znq2gvPFdwWAGgA+AvChqT8A9AfwDwBHw1mP7wC8XkiRbwKYZPL2AHCliJxi0m4F8CqA5gBOK9hhReQcAEtVdUY865IkzwLYA2d7HgDgucJ+dMRgKIBWAJoB6AXgZon/iDUfwHgAZxb3PUWkDoD3ANwBp81mABhdyHu9BeBHALUB3A5gjIjUNWlPAOgHoC+AYWJ+4MPZdx9S1W0lWblEE5E+AB4GcDGAqgCOAbAkjvLqwPn8X4DzubQE8Hn8NcUcAFcCmBXlPfsCuAXAcXDa9UAAd/uyFNZOkYYieJtM2j5bmjrd0q4fgJdV9Q9V3Q5n4z1HRCqLSDaAngDuV9W9qjoHwBg4X9rFKgtAUwA/qupWAF/C2agAp7P9UFWXJWn9EqUtnB8Sj6tqnqp+BeBbOD8ySqofnB9RO836v4zgzzZWfQFMVtUpqroPThs0gtNhAs7ONkVVl5gfbKMAtI9eFADnB8EbZp1/AzAFQEEn1RzAV6q6BcAPAA4UZ2TjFgC3xbkeCSfO8OGZAO5Q1e2qOgXAh4ivDS8CcK+qblLVBQBeBDAonnqq6hpVHQbnMy3ue54BYJ6qvququ+F8AXcWkbaRhZgfjIcCuEtVd6nqWAA/wevsq6jqz2a/3wOgtoh0A9BcVd+JZx0T7G4A96jqNFXNV9WVqroyjvJuBPCZqr5hjuC3mc85Lqr6rKpOALA7SvJFcL4756nqJgD3wrRpDO0Urayg7SNp+2xp6nQfFGdI9VsR6VnwRxFpKiKbRaRpMcu70gwNzBSRoA+9uCQizoLzS0kC0juWoKxfAXQSkRoAegOYJyJNAJwL4L9x1T51rM/CtOdRJSgjanlx1ssf+8t9G0ALceYbM+HsoOMLKesJABeKSKaItAFwBJwfTQDwM4A+pk27AJgH58viCVXdnID1SLTWAPap6mLf3+bA/Igo7j4pIjUBNDRl/KW8ZIjhPTv408yQ6W8BdeoAYEnEEau/rLUi0llEOsM5+t4E4EkA1yZgVRLCHH13BVBXnCmfFSLyjIhU8uUp7n55OICN4kzNrBWRj0rwPV1cVruZuL6I1EbR7eSKYftI2j5bWjrd/8A5omsEYDiAj0SkBQCo6nJVraGqxZmzfApOB1YPzvDRSBHpHmcdxwO41MwZVDd1BoDKppG/BXCHiFQUkUPh/LqqXIKyNgC4H8BXcIapb4KzA/8HwOki8o04c8eN41yfZFkEYC2AwaYDOh7O0aP7WZj2LM5JQuMB3CIiVUWkJZyj3KDPNlZfAughzgk6FeD8eq3gK3c1nKPVRQB2wRluvqGQ8j4GcJbJuxDOr/GCI7AH4QxTfwNgmHmfg+Bs52+aObGr41yfRMoGsDXib1vgDEmWZJ/M9pXxl/KSpKj3zI5IK6xOReW9As4+OhzOaMC/4GxfFUXkMzPH2AOpVR9AJpxt9GgABwM4BMCQggwl2C8bw/kxeh2cEbqlcIZ3kymyLQriqlHSCtKD2tT/+si8SdtnS0Wnq6rTzdBErqq+CqcD+3sc5c1S1Q2quk9V/wdn7u6MoPxin3AV9EttBJwNaiKcXz1fm7+vMP8PgDMk8QecudhRvrRilaWqb6nqoap6Ipwjr1w48xT/hTPU+i5K6VGvqu4FcBqcHwx/Avg3gHcQ/FnE4lo4ndkvcOaL3yqsPHOiQ0F7Dgio50I4XxjPwOlg6wCY7yv3TgCHAWgCoCKcobmvzBRA5PvVgvPD4B6TtwmAviJypXmvjap6jqp2hvPl/DSAa+AMVf0MZ0TjChFpF/MnklzbAVSL+Fs1ACWdm9zuKyOm8mLcJ+N5z+KsY6F5VXW2qvZU1b/B2Yb+AecEopfgbDcXA3hdRASps8v8/7SqrlbV9QAeQxzfs6bM91X1BzNEfzeAI82BxF/Esl/GILItCuJtUdIK0oPa1P96K28y99lS0elGobCH/pJaXsQJV1F/vZs5kLtUNUdVG8PpLFeaf1DV31X1ZFWta3a+OgC+L0lZBczQzwNwOq5WAP4wc70/wPnVVSqp6lxV7aGqtVW1L5xRjKifRYzlbVTVAaraQFU7wNluA8tT1RN97Rl4lqiqjlHVjqpaG8BdcOZlC45OD4ZztuYK8+NtJICaiD6veyCAPFV9zeRdAWd4OtoX2uUApqnqzwA6AZihqnvgzD11ipI/FRYDyDAnmxXoDGc7LTYz97balBFTebHsk3G+5zx/mpnHbhFQp3lw5vT8R0xB9X8cwBBV3QWvfZfBOcoMOqEn6cznsQLOd6H75ziLnVuc8mLdL4tgtZuJ15gRwpjbqZjbZEL32ZR3uuKcVt/XDMtmmF9Ax6Dw+bOiyjxLRLJFJM0Mb14A50SQeOpZS0RaiKM9nF+J96hqvklvZ4Y/K4jIBQCON3mKXZbPEAAjVXUVnEuC2ohIfThn2pX4rMNkE5GDTHtWFpGb4MydjIyjvBYiUltE0kXkRDg7QdzXOIpIF1NmXThDgx+aI2DA6Xz7i0h9sx0NhPPF+WuUohY7xcn5Jm8DAOfA+VLyv189AFfBOWkHcIbjeolzIl5XlJI2NfOb7wG4R0SqmKmZU1H42dtFeQ3AEBGpKc7JSpchjm2igIhUhHM+BABkmeVY3vN9AB1F5EzzmjsBzPW1v8vMbc8GcJfZrk+H86N3bERd+gCoqKofmz8tBXCsOGd9ZwHYEO/6xukVANeISD0zp3kDnGmReMo7XZzL5TLhTOVNMScflZj5Dq0I50Ap03zmBX3VawAuEZH24sy3DoFp01jbyafIbTIp+6yqpvQfnF9/P8A5rN8MYBqAPr70pnCGApoGvH4kgPsi/jYZzvj8VjiT4+dGed1EAJcGlNkTwIqIv7WGM7+3E8DvAG6MSL8ewDoAO+DMBXaNSN8O4OhYyjJ52prPJd33t8EA1sMZwuoUkX8ZgN6pbk9Tl/+DczLJdgCfAmgZ9FlEee1QAKMi/nY2gFXm85oNoG8sr4tI1yj1mGK2u41wLnuo4kurCOeymdVmO5oF4ARf+vMAnvctH2vaawucYfUX4czR+9/vNQD9fctNAEw3n9VjEXkHwfkCS1Ub1gIwzmzPywGc70sryT6ZBWdaZSuANQHbfLH2SV+7Wv9ifU84Q4QL4QyTTgSQU0j75pg8u+Dsu72jrN9sAM18fzvO7JerEfEdFO0zCqFNM+HMT2422+hTcH4klGi/NH//F5wRuk1wLrtrEsvrItovcr+cGKVde/rSbzTtuRVOx58VSzvBmQKcV8xtMuH7bEp26ARvSC+ajeW3GPO3MhvdTgCDAvIcYxptM6J8wZemf2bH3mzq2yvV9UnA+gyB80W/Gb5OsIjXLDLbwIhC8uyG0yHem+p1jGF9voDzY2BCqutSwvqX632yiHXNMuuwA86lLSmvU4z1Lvf7ZRHrGvM+y0f7ERERhSTlc7pERETlBTtdIiKikLDTJSIiCklG0VkSp09af04gp8gX+e8m/MJ8tmfqJKM9AbZpKnEf3b8EtSePdImIiELCTpeIiCgk7HSJiIhCwk6XiIgoJOx0iYiIQsJOl4iIKCTsdImIiELCTpeIiCgkod4cg4iIyp+0ypXduMvUbVbaXXVnu/Hx889w4wp9fk9+xVKAR7pEREQhYadLREQUEna6REREIeGcbhJkNKjvxntaHRDTazIXr7SWF916oBvXmO/dN7vWgt1WvrTJP5akikRlxu5+3azlSp/OcmPt2t6Nl55Sxcp39LE/ufHkrzoFlt/wuzw3rvjR9yWuJ9n887iLh7dx43F1h1v58n3xH3MaunELcE6XiIiI4sBOl4iIKCQcXi6hLRcc7sYb/m4P+d5yyHg3vrDa/2Iq7+UtTa3lM6q+78Y1+1cMfN3JjbrEVD5RaZdep7Yb542u5MZvt3rMyrcmL9ONq6dNdOOmGZUR6KJJgUlrL9jpxqueqmCl/fOB69y49ovfBZdPf7Hk9s5uPL/XU248YMmJVr4N9zd34xbjpyW/YinGI10iIqKQsNMlIiIKCYeXI6R1bufGC6/xzoacfPwTVr666T94r0nAb5dLqi+P+EvwkDLR/mjxk94Uy6K2L/tS7GHjeulePGxzazeetc2eolmxo0bge6WLd87sJ20+ilo2AIwe8n9ufMWCq620tCmzQcH21NsX9e9zJ7eylpuPL1/D9jzSJSIiCgk7XSIiopCw0yUiIgoJ53Qj7Ghe1Y0Xn/icL6XSXzPH6fnN3l2n3vj9sBKVUR2/Jqo6+720g727F+1uYN+9aNlp3l2/zur2g5W2V72Jvq9f9+6O1PCbLVY+/XFeQupZXugRna3l0Ue+4FvyvprG77LndB8afJEbV5233ktYt9HKl7bpj+D3TvPatPWjV7rx/LOftvK1yMx2411Dtlpp1Qd5d57b9+eawPcqrzKz97jxtnwvbvpFbiqqU2rwSJeIiCgk7HSJiIhCst8OL2c0bmQtL/hPYzeuP9UbSqz2ln0HlLRcdePFe70hkT/22ZcfNMnY7MaDfr7IStu0wLuzTv0fvPJqTLWHu3T7djeuvpnDxImg3Q+2lpdc5cVvHvGiG3epEHFtSKwGezfE33XTHitp+GZv+HrYnB5WWqtLFrhx/m77Dmbl1d7q9t2fDq7gfR3lw9tvBr/yDytfk/enunEeSijfe2XLG7zvgHYV7MuC5p76pBt/02mMlda9tzcsXX0Uh5fTWza3lucdM8KNr1t1nJfv61koz3ikS0REFBJ2ukRERCFhp0tERBSS/WpON71GdTfu9slSK21cnQ/duPsMe97GL+tT73KRwScNcuO8eYvs92rn3cqs1qLfrLRa+Yujlh39pmhUEvlHeXO3y7ypNXzS/VkrX4sM/6Ve3jzuF7vsS8Bum3+aG29ebs/f/3yadxnJHWu8p0s90mCGla9zJe+h2491G22l3XrDIDdu/OBUEJBXUQLTDpo6yI2b3h/e59XqqunW8se9vYeq98/eYKVtPmWHG1cfldx6lQWLhgbfdjNMuSd6l19uaxLcxdWdaV8CpjPDueSPR7pEREQhYadLREQUkjI9vJxW0X4ST+4Yb3j5tjpfWWlt3vPGINu+7w0jFHbJQeSQspW24JcYa0mJsORN+1KgNwIv/7GHjc9b2seNf1joXdLQ9roFVr66O7y2rhvx3ld06e3Ga69t5sY3PGdfdjSk/kQ3nryroZU2+2pviPq0Uae68b4/VqC8anNr8HBe+syqgWlhuv0Hb9qhf6+XrbSrOkxy449RM7Q6lVaP/210YNq3bx7qxg0Q/3TBb28cYi0/+be33LhThSluXD89K7CMX/faE36njrnBjVvcNC0ye8LwSJeIiCgk7HSJiIhCUuaGl9NresM4C+9tbaUtajfMjemtDZQAACAASURBVGdG3FO77T1L3Dhvq33WGpUOaVXshxD8ck8nN17Qwz4rOc13JvIPvruIDfjgKitfm7u9YeTWm72zjfMRu05VV7rxFxneEPWM/+ti5av9mHfm62lVNsMWfKZueZJ2UFs37lnjCytt8V7vTl115u4NrU6FqfmNbwqrV+rqUVqlV6vmxlXS7C/dz3d5+3ODx2MbUpZM7y5le3odZKXd/twrbnxMxZlWWqZ43wff53pDyhcu7G/lu7H55258SpWdVtqw07zpgydGnO7GefOjX41SUjzSJSIiCgk7XSIiopCw0yUiIgpJmZvTXXVBOzdedLr9wOkPd3jzvS+f3MdKy1tn3zWKSp/Np3Sylr/q/183ToP9IPMJu7x5m4eu9J7y1PJz+1T/WJ9CIxnerpDWpoWV9tK4Wm78f6+96sadKqyNKMWrY7rYv2c7TT/fjRutLb/b4i8XeXctOjd7nZV21NyBblztfz+ASr+l13d046MqTrDS2n99oRu3xI+BZfifTrToqvpuPP/sp6NlBwBM2JVtLV/52SA3bvvkejfOWmzva8/COw/o6QlNrLSP277nxg829S4/rTA/sBolwiNdIiKikLDTJSIiCkmZG17e9rddgWlPLvUelFxpcfkdwiurNOK58rs1+DKbbfnenaf+/Jt3mcGuM7pZ+Vq2Wh319Vt223cz69/Me7D2VTVet9Jm7PHK757lv9jIHvL2+3a3fVFSo/u8ddHc3Mjs5cYNJ37ixv5LhACgwrO1fUvcf8sCOSj48svM3yoFpvn5H5SwsJd3aWDkZX0DlpzoxltvbmSltfrOu1wv1imlX5c0sP/QNnq+ROORLhERUUjY6RIREYWkzA0vv9V9uG/J/s0wpr33UMsjHvu3ldb8wz1unD5xFqj0qfmBfQP8yy8c4Maj2toPLD2lincXqjP/5d2JLE+D7zWVq94NzrOksE3fTrOHlD37Igayes49141rXWWn6ZJwntVZlryw4RhrueLH36eoJlRSbeutKfZrpEsHa/n9o57zLWW6UYeJl1v5Wl3i3V1Ods8p9vsW5c613nN4K078yY2Lc/e6WPBIl4iIKCTsdImIiELCTpeIiCgkZW5Ot1uWN+a/V+15s5pp3mUgC8+xn0qz92wvb8cJV7hx9R/sS0e2N/bmCqt5DyZCnbk7Auu0/iD76Tj1J3p3KsrjpUsxy9+2zVrOOt5bvrz+GVbagqE5bnx8F2/+ZfGWela+31fWceP0Ct42cEqbuVa+RxrMQHG1/9qec2rzb+9pRPvWRN6tqnxKr1HdWq6atiJFNaFkaFzZe5pWWuQxnCiiWXyt/WD5dpned3qXHy5w4xYD7LtYJXpuNTN7j7W8Y59Xr/zduyOzJwyPdImIiELCTpeIiCgkZW54uflHl7nx4pOfj/l1/occL+r9opfQOyHVsnx/i3f3oevn+y4jOTmxD0MuT/Iihmtb/8tbXub7ewX8buVrFbFc4PP321vLhQ0vL9vnPez6tKdv9sp+wr7EJW/fPpBtxSX25SEDqn7txrN25IRcm+LL/fuWwLSd+RUC08qLfPWO2/IjB4AD7ijXsP5ma9n/uvZ1vUuQNiWgfpH8D1eYd8wIK+2YuWe7cbUk3hGNR7pEREQhYadLREQUEna6REREISlzc7ptrvJOI+/7rn3JxoXPfOTGldPsJ7mcXNl7YLZ/fjcZumV5p8pPOeQNN+7wf9da+VoM/i6p9SDb0geOcONZhz0ekRo8P3fWI9487gHPTnXj6BdEUFm279gu1vLbhzzjW7IvdXn/Ye+pZtUxLZnV2q/UuMS+HGf6ZO+SoWeaet/hRzx8k5Wv9VPe+Rn7Vq4q0Xu3G+2VsSbPfmJdxSdr+ZY4p0tERFTmsdMlIiIKSZkbXlbfZRmZX8600t5qe0Dg6546y7t0Jy/TO5X9yJvsyz4eavBDvFW0+O/S0rhz9AeqU/KsGnykG3824BE3riTBD6B/clNLa7nBK7PdONF3xaHU8w8pb7zOvvNc20xvSPnKld2ttBqjvaeVlZepBv8lNwBwTPWvil1G5NDww71Pc+POY73bAP58wVNWvit79HLj1SfVstLyNmx0480DvWmko66fbuW7s/63btzlbXv4usX4cKYIeKRLREQUEna6REREISlzw8slVWXM9Kh//6jzEdbyQwO94eWd6t0Qu8ukf1n5mr3knQG9/tqdVtqMw+wHrlN49h7f1Voed7U3pNw0I3hIebnvrlMf/uc4Ky1rZ2KnHMqTasvsh5L47+6VSpLhffVtvsF7sMaMQ9+28n2xq5IbL77DvrtWhb3Ff0hGWZf361Jr+e0/u7nx6S3GW2nNjlruxunVqnllbN1q5du3ZJkbzzzEOw48ZqB9tUetud6drKTOXitt6TNN3HjeMd4Z55FnKPuHlFvclJozznmkS0REFBJ2ukRERCFhp0tERBSScjOnG6TpZ/adqzDQCyuLd5eiBT1etrM16+PG/8v5LKLU6L9llv9pn+beyno+DiXCspPtu43lBMzjrs6z5xYvvP7fblz5k+jz/1R8Vcban+X4e9u5cYuK66y0Xxp3dON9K1bG/d75Rx3sxkuvtNPObOddBvZAPXse1++Bmy5y40qffR+Yr7zafak3V/vY2LZW2sdtP3Dj6yZ4l1t9/7x9Hk32quhP51p3mH2B3mHXepcTPXrAFCvNf2nm8C05bjzyvydb+VqMSP1dAHmkS0REFBJ2ukRERCEp98PLmTN+sZYPn3WeG0879K3A172e84Vvyf7tkqve6ewn+x5i3/Za+yba9sUUVFLptb1h+x/PeCIiNQvR9JxytbXc4n0OKYftyhr25SdrPvaGKmdsbBp3+Q81H+7GB1cI/qqbucfbEwd+f4mV1uKrhW7M/fWv8hZ732mTTrUvqar5iXd3r8cPmOwl3DMZQfzDxPnFuP9bxykXu3HLG9e7ca2VqR9OjsQjXSIiopCw0yUiIgoJO10iIqKQlPs53fxt26zlBtfUdON+I05x49tyPrHyHZHlzfCM3V7HSrv9f+e4ccsbvFuNcU4ocdJreu10/XRvjihbos/hAsDDG7zLVVpdZs/l8+lB4fBfwrH2uklW2t1153gL/rjEvK+3fRF73xzvDq+4YLR3u8Hmt9hzgNxnY+e/nSMAjOvpXQL21MXek4R2NLdv4fjZCd55GH0/u95LKOTRTW1e2m0t5/ww16tHLJVNIR7pEhERhYSdLhERUUjK/fBypH3LvCdj4FgvvPZa+5Y22w7znl7Rdsh6K63l76l5ekV5sv4U7+43x1f+2o3zChmS+t/dPd24yg5eIpQKtXx3BPphUmsr7bFx3pDhjTXt4f+SaPvNP9y4wk/2nckaPzjVjZuj9F1Wsj/IW7PWjRs9tDYw3zXw7lbVGrE90auQ3bzU45EuERFRSNjpEhERhYTDyzGq/9RUe9kXl/az5fZHZ970pRvnafC5xy0/usKNW4/lkHJpEvlA9C87VvViHBp3+QdidtGZiELGI10iIqKQsNMlIiIKCTtdIiKikHBOl8qkzpW8S7vSxfvtOG23fQ+h9o94lypw7p2IUo1HukRERCFhp0tERBQSDi9TmXT9G97DxhdeNsyN/zHiGitfkyX2pV5ERKnEI10iIqKQsNMlIiIKCTtdIiKikHBOl8qkZnd5c7V97zrYjZuAc7hEVHrxSJeIiCgk7HSJiIhCIqpl+XHAREREZQePdImIiELCTpeIiCgk7HSJiIhCwk6XiIgoJGW+0xWRoSKyV0S2i0iVGF/zm4jsEZFRheRREdkhIvcnrraJJyJZZt33ish9qa5PSYjISNMey2LM39qsc56IXBqQp6eI5Jt8JyS0wiEqi+1b3vfJoojIVyKyW0SmpLouJVHe91cR6W3qmS8ivYv7+lLR6YpIO7MhbhGRX0Xk9GIWMVpVs1V1hymvhoi8KiJrzb+h/syq2gLAAzGU21lVb/fVs5+I/Gw+8Kki0t6XliUij4vIKhHZJCLDRCSzkHUurKzjRGSpiPwpIuf6/l5DRGaJSFXfuuSqajaAN2JYn6QRkVoi8r75UvxdRM4vZhGPqGqOr7wsERkhIlvN53BjQZqqLjbrPLmIMleZ7WK8KbOhiHxo2khFJMefubD3NOnHichCEdkpIl+LSLOgNxaRHJNnp3lN74hySnX7isjVIjJDRHJFZGQJiojcJ3uZz2NLtC/rOPbJ4SKyyHwBDoqyHjeYz3mradssX1pgG0UpJ3DbEJEmIjJNRDaKyKMRr/tURLpGrOuxAK6IYV2TRkQmmo5/u/m3qJhFRO6vBR3xdt+/dCCu/VVE5HYRWW4+97dFpJrvPedFvN8+EfkoYH1vi8i7y2wzdUz6YBFZb8rs5HtddxEZ5y9LVb8067McJZDyTldEMgB8AOBjALUAXA5glIi0jqPYxwFUBpADoBuAgSJycZz1bAXni+8KADUAfATgQ1N/ALgFQFcAHQG0BnAogCElLOsJAP0A9AUwrGDjBfAggIdUdVs865IkzwLYA6A+gAEAnhORDnGUNxRAKwDNAPQCcLPE/ws4H8B4AGcW9z3Nzvke8P/t3XeUVEXaBvCnSEMUYRSQMESRIFnMBFEX9VMEhVVMoCKLYlgDa0JB1E/93M8AghFUXCPqCHjWDBgWkSCSBFSSoAgIkuMw7/5Rd+reunb3dKwZZp7fOXPOe7uqq6un+nZ1Vd2Ae6A/p3MBvBnjtV4HMB9ANoC7AbytlDrSSzsU2vdXAA8AmJCm8nZ5ZQ1LU3kFFgC4DsC34QSlVE/o/fJ06DZtAuC+QJZYbRQ2EtE/j3cCeBlAYwC9CzpZpdRFAFaJyNwU3l8mXe91clVF5Jg0lPd/gfKqisjBFMu7AsDlAE4BUBdAJQBjChJFpHXBawGoBmAtgEmRChKR/w3WDcAjAGaIyO9KqaMAXA39+Xgaej8s6Jv+H8DfU3wfliLvdAG0gP6HPi4iB0VkGoD/QP+zk3Ue9Adgt4isBjAewFUp1rMngC9F5CsRyYNutHoAugVec7SIbBGRTQBGx3jNwsqqIiKLRWQBdEeWrZQ6HkBjEXkrxfeRdkpPIV4I4B4R2SkiXwGYgtTacACA+0XkDxFZCuB5AANTqaeIbBCRcQDmJPGaFwBYIiKTRGQv9JdwO6VUi3Ah3g/GjgBGiMgeEXkHwCL4nX2xb18ReVdE3gOwOU3lzRaRVwCsTEd5gXLHishnAPZGSB4AYLyILBGRPwDcD68942ijSGVF+2w0BjBNRLZBf7aaeCOyOwDclYa3WVqdB91+a0VkJ/T35EVKqcoR8nYFcASAdworVCmloDv0l72HcgDMF5HtAD6F7nwB3dlO8fqQtCkOnW4kCnrEqDeU2qqUOjWJMiKWl2K9gnG43HB6faVU9STK2qiUaqeUagc9OvsDwJMAbkyh7pnUHECeiPwQeGwBgNYAoJTK8dowJ57ClFI1ABzllfGn8jIhjtdsHUzzpk1XRKlTawArQyPWYFmHWvv+SZL7pGtWm3lxbaVUNgpvIyOOz8ZiAGcqpQ4H0AnAEugO/gkR2Zqm95IJD3lTqv9RSnUveDDR/TXgOm+KfZ5SKtqPl0SFvyezoGccwgYAeKdgOaMQXQDUgt9B/wSgjdd+ZwBYopRqAOBiAP9MtuLRFIdOdzmAjQCGKaXKK6X+Aj3iM79mRORwb/QUrw8B3KGUqqaUagY94oz06ygRnwLopvSCfwXoX7AVAuV+COAmpdSRSqk68L9AI71uYWUNgf4Sfg56tHit95yKSqmPvHWobhHKLSpVAWwPPbYNesoHIvKz14bxroFUDZTxp/IypLDXrBpKi1WnwvIeau37J0nsk0Uh3A4FcbUIaQXp0doz+Pxw3oegv8g/BzAOel9uC2CqUuo1pdQXSqnrk30TGXI79IiuHvTncKpSqimQ1P4K6Jm9o6E7s3sAvKSUOiXFOn4IYJDSa+/VvToDoe9Ub+TbF8BLcZY7AMDb3ugZIrIZwIMApgH4HwC3Qe+ftwPoo5T6XCk1WSlVP8X3A6AYdLoicgBAb+g3+xuAWwG8BWBdCsXeCGAPgB+h14tfj1Wed7BDwQL7pVHquQy6sZ4CsB56KuP7QLkPQq8PfQdgJoD3ABwAsCHRskTkOxHpLiIneI9fBX2QyQvQa1JXAnjFmyYpDnYCOCz02GEAkl2b3BkoI67yQgdJJPoLPZ7XTOQ9xsx7CLavc/Hsk3EIt0NBvCNCWkF6tPYMPt/K6y0pXSQi7aC/rMcAuAF6enkx9OhpiFKqZZLvI+1E5BsR2eEdqPcy9JLeOSmU962IbBaRPBH5N/QxKxdEyx/n/joB+rt7BvTswXTv8fB3+QUAtkD/6InJ66D7wZ9aLqj/6yLSUUTOhp5x3Af9ff5P6GnuSUjTqLfIO10AEJGFItJNRLJFpCf0L7DZKZS3RUQuFZE6ItIa+n1GLU9Ezg4sskc9SlRE3haRY0UkG8AI6AO15nhpe0TkehGpJyJNoNfC5olIfqJlhTwOYLiI7AHQBsBcb42hPIBoB3249gOAct4BYgXaQe8oCfPW39Z7ZcRVXugAjoSPKozjNZcE07x17KZR6rQEel0vOGqKVv9DoX2di3efLITVZl68wRvZxN1GCX4eBwOYJSKL4bfnfuj14jYR8hcXAnsqN6PlxbO/iki+iIwQkUYiUh/6//2L9xc0AMBEkbhuJNAHuoOeESlRKVUJ+gfwrdAj97XeWu8c6NmLlBWLTlcp1VYpVVEpVVkpdRv0+slLKZTXVCmVrZQqq5Q6G3pHSPkcR6VUJ6/MI6GnZKZ4o1Yopeoppeoq7UToKZYRyZQVyHMmgIoi8r730CoAPbyjgrOQpoNcUuWto7wLYJRSqoo3rXQ+gFdSKHYigOFKqRrewUrXIIXPRAGlVEXo/x0AZHnb8bxmLoBjlVIXes+5F8DCcJsB+hQJ6BmPEd7nug/0Dmsd5FGc21cpVc57n2UBlPXeR9L331ZKlfHKK683VUVvaSXVelbwylUAynvlFnyvTQRwtVKqlbdeNxxee8bbRgGFfh6VUrUADIU+yA7Q7XmaUqoq9JkNaT2ILFlKn5rWs6BNvZmErtDTucmW2VcpVdVr578AuAz6YMpU6lnT+y5XSp9S+RiAUcGBjDflexpCI9cYCuughwN4SUR+hT4l6BilVG3vNdLTfiJS5H8AHoU+mGQngA8ANAul7wTQJcpzRwL4V+ixv0Kf8rAbesfqGc/zQukSoR5fQU8pbQHwLPRRqAVpXQGs9l5zOYBLQ8/9AMBd8ZTlpWd5dW8YeOx07zXWA7g4lP8lAA8UYRvWhJ5S3wX9Yb0kkJbjtWFOlOf+qe7e+58AvVa8AcAtEZ43A8CgKGV2B7AuSrtaf/G+JvQ04TLopYsZABoF0p4B8Exgu5GXZ4/3eTjjUGpfb/8I/69GBtIT3Se7RyhvRmHPi9B24X1yRoRyuwfSb/HacjuAFwFkxdNG0Ke9LUnw8zgRQL/AdgMA30B/tz0WyjsQwFeu2jP02kdCj9x2ANgKYBaAMwPpyeyvX0Kvc2+HPsjs4gjPm4EE9lfoAzSXQ3+nronyP78T+kyQSGVan1Ho9eu88GcokN7C+7+UDTw2DMDv0MtAbUL5VyO0X8f1/y+KRk/zB2g49Bf9VoQ6rhjPWe41yIQYefZ6H6L7i/o9FvJesrz3vgv69Icir1MS7+F5rz1WxJn/aO897wYwMEqert6X6VZE+NF1qPwdiu1b2vfJON7rJ16H91lR1yXJ+pfq/RX6x/FWr76nJfp83k+XiIjIkWKxpktERFQasNMlIiJyJOmjEZNxZpl+nMsuIp/kT0r7OZ9sz6KTifYE2KZFiftoyRKtPTnSJSIicoSdLhERkSPsdImIiBxhp0tEROQIO10iIiJH2OkSERE5wk6XiIjIEXa6REREjrDTJSIicoSdLhERkSPsdImIiBxhp0tEROQIO10iIiJHnN5liIgonX56/EQTr7joGSvtijVdTbzhpO3O6kSJyevRycSr+vhd0q2n/9vKN7j6ahOXgX0Dn3z4N1MasbGDiaeuPtbKV/ehsv7G7EVJ1TdVHOkSERE5wk6XiIjIEU4vU4lWrk5tE287pZGJfznTvrf3ql7PmfiAHLTSTvnuYhNvWlvDxK0e/s3Kl7f655TqSok75cTvo6ZNbPiFibv0+ZuVVjn3m4zVqbT65faTre1dR+83cf9Os6M+775a/r6Xj3wTlwmNCYNpLWcMttJqTckycbU3Z5m4LqJ/PooKR7pERESOsNMlIiJyhNPLdMhTWf7U0sr7OlppT/V9wcTdKu2OWsYB8X9/BqexAODL9q/5G+0DYfZVVr6cfnFVl9IoOIUcy69d7aNdm+Vmojal24Ibn7K2g0cUbzi4x8TjNtvT0M0/8Kf+q/xYwcQVf7eXgLLHf23ippifWmWLEEe6REREjrDTJSIicoSdLhERkSNc0w052N1fEyx37wYTTz1mipWvvPKvbBLrFJPsu8ubWK3+xcq3+bxWJq753mIrLX/HjkSqXar9PMy/os2iy59Mqowr15xu4vENP4nrOd+dPMHa7oXOSb02ZV6zm2cVnolS0nVRX2t7Wps3TRxcx53XwR7rNcfczFasmOFIl4iIyBF2ukRERI6Uyunl4CkmO3q1t9JGPORPGQZPMbFPIgEOBI5mj3WKScd7Bpq4XR37N87kRv4h9p0Pv8FKqz1mZuTKEwBATmpn4glXjUn4+W1fvNHabnz/tyZu8fhQK23Z+WMTLp+otDn8mv3W9vufZZu49+HzTPxdy0usfAeX/pjZihUzHOkSERE5wk6XiIjIEXa6REREjpTKNd193duYeNoTT0XNN31PVRPf+4B9yb/yuyWc3dje0P8tUyFw5cF/3GafYrItP8/EVdfbpx2RLbiGCwDywBYTd/KX6P+09p67s5aJJwzsZeJG39h3PZF8//9/zM0LrLSz37vWxPc/498R5bgsu83OWOyf5vXpsdXCb4EyoOmbQ0wcvol9UPBm9wBPIcqEvLXrrO07ci818feX+d+z++vY+0bZpZmtV3HDkS4REZEj7HSJiIgcKTXTy8HpyYeefjZqvv4rzjHx9hENTFxj+teRskdUvVljE7eftMLELSvYv3FaTL7ZxM3f5k21Y9nYuYq1PaeFP1UfvDrYtnz7tIURb/lXB2v0dXxtKPv2WdvlP/avmHPZR/505pLz7KWJYTX9tn7+9QFWWuP+9pQ1pUesKWUqYoEbO5UJbGxuXdHKVlN1Qjyy5vqnFh3cvj21uhUhjnSJiIgcYadLRETkSKmZXv7jbv8mysGjXc9ZdoGVr+xth/nx/G+RjK2dapt4RK23ouZr8HFSxZdKZc7YbG0HrwIWvDrYlSt7Wfka3RP/skA8ml/rH/U85tTWVtotNZeZ+NJWc6y0magAopKsXIP61vbDvV81cfCG9rPutG9KUiYw9gvu12VCY8Lui/qZeN8ke98L3uC+uONIl4iIyBF2ukRERI6w0yUiInKkxK7prnqjrbW9pMOLJl6X56/vlrm7hpVP5i9M+LWCdy0CgGZ//94vP/C7JnijdACo9J59VSSylatX18S3HvNpXM9ZOeloa7s2NqW1TkETJp9hbd9y5bIoOYlKpuA67jkf2afF9aryh4lHbOxg4qmrj7XyyazDI5bd6+KvrO1bmvjfAb1HbbXS8kf5a8ZnXT7YxMHTjIDicaoRR7pERESOsNMlIiJypMROL1/Ryp66DR6KvibPPy0IsxKfTgbsKeXlT9gX45+c49/0PHgB/jWPHmPlqwxehSqWP07NMXHfqpOj5hu8truJ6wWuAAYAeSgax1ayL/4+u0kPE+etXO24NkSZsbO9vwQ0uLq9j3Zd+FcTH3a2v1/WxfeIx7xH7DHhgvpdTDx8UEMr7cSzFpn4w1f8m5KM3drUyvfBlX4ZmL0IRYEjXSIiIkfY6RIRETlSYqeX061sa3tqeOkN1U287Lyx4exG8J681WaustJ4B93YNnVUhWcCsOLhliau9FvxOCL83Cr2FbQeO66Oiatyetk53j83MypO9fe3c6faNy44DCvC2VOSt+4XE+eM/MVK+3WkH3e4/QYTh4+Avv9N/0Ypd149xEorN21eGmpZOI50iYiIHGGnS0RE5Ag7XSIiIkdK7JruO6vaW9vDsv3Dwztk7TJxl4V74yrv+MrvWtunVfKflx/OHHDrgr4mrr9hSVyvRdrBytHvOBJUXK7sVV6VNXHwzkdE5E69R2aaeMGrDay0oz7aZuJRLzxvpd304FATZ/KuRRzpEhEROcJOl4iIyJESO71c5zL7kPJe7/Ux8fst/CunBKedE9ElcFh6fn/79JAv279m4lrPV06qfALatl1t4vyYk/jFwwHxTwI7FOpLVNIFTzMCgEl39TTx+pH2aWTjho828YAGN5k4Z+RMpBNHukRERI6w0yUiInKEnS4REZEjJXZNN3/HDvuB0/3tHn2uM/HGTtF/d9RY6p/3Uf1Ve/5/0yv7TLys/RtW2vhtjUxcecl6ExfVHW/IvTV5+63tSpv2R8lJRK5UmuyfXrhgXvTTib675kkT9xrZOa114EiXiIjIEXa6REREjpTY6eVYKuf6N49vlJtcGct6vGDi8OkhY5d3M3HdtfHdsJkOPYN6fxw17fwXh1nbOdPTe9oBaVes6WriiQ2/iJrvp8dPtLZ51yEKn040esFpJh7SbWXGXpcjXSIiIkfY6RIRETlSKqeXkxG+iT3g3/A4fKRq7dEVHdSo5Nt1b10Tz32xrJV2XJZ/9aefJ7UxcU6/5K4wlozOlVZZ27P3KRM3enSBlcbrUxEVM8e3sTZfOXG8icdubZqxl+VIl4iIyBF2ukRERI6w0yUiInKEa7pxWjmiQtS0fvMHWdt1pn+b6eqUCmU+n2/ioU9cb6XNuX2MiT854WkTDzztRitf2TS3xao32pr4DLlKQQAAA/xJREFUlIrzrLST5/c3cc1dP6T1dcm3u88JJp7Y8NkirAkFrbnvZGu74u9+XHtM8Thlrmyr5ibePmqXlVa/3B4TfziwSyAlvceJcKRLRETkCDtdIiIiRzi9HIOc1M7EU04YF0r1TwtSn9VwVKPS66gZW6zt43pcZuK5nf9l4nXd7dO1Gk5P/bV3XehPZ751gn+j66/3ZVn5aj7AU8VcaPyPpUVdBfJsvvokEy8aNMZKaznDX3arbSelrFyD+tb2mktyIuZrco59Zam7Grxu4ll77NOC+oz0ryJXc87XqVYxKo50iYiIHGGnS0RE5Ag7XSIiIke4phvDxs5VTNy4nL1eF7yzULm9Asqs/IXLrO16d/uX5czNrWniKQMftfKddcQtJj566DeIRnVqbeINJ1W30p691b+hdcsK/u/UFlMHW/maz5oNSr/gKUJA/KcJdRn6NxM3y+VdhTKtvLIv1bq0u38ntvmr/O/LS76+xsqnAnHXJj+ZePnWWla+6W0mmbgM7FMB8yGBNL/EcVsbW/n6T/M/E61GrrfSaq7L3DpuEEe6REREjrDTJSIicoTTyzHsPcKfsgjfqP6JLa1MnP28m2kJ8h1cstzEL5/l33z62efsdvrw3MdM/FaXTiZ+47UeVr4XBvvnNHTIin5PoLO+72viFk/vsNJ4JyH3mr45xMThG9NXRvTlBEqP7PH+d9/Ju4ZYaRvP2xfxOS+fNN7aPj7L/54N3t0n35p4tk9Byt9sXyGwSe6BiK9VYd5P1nbz7XNNnBfxGZnHkS4REZEj7HSJiIgc4fRyDJf1jn45owmTzzBxI3B6uSjlrVxt4qz+R1ppQzrcZOLyt/9m4nk3PGnlazF1aNTyG7/rTxxnTV9o4vwD+xOuKyWucq49Tdwzt72Jm4FHJRcX1d6YFdqOnG8UOsZZor180xTzo+SL7mDCz8g8jnSJiIgcYadLRETkCDtdIiIiR7imG8M7q/y1o2HZ6b2RMWXGwU2brO3yHwe2P/bDXuhs5WuO+K4mxWuPEVEqONIlIiJyhJ0uERGRI5xejkE+8y+kf1d9+6LrtecWx4PRiYioOONIl4iIyBF2ukRERI6w0yUiInKEa7ox1B4908SLR9tpleI8xYSIiKgAR7pERESOsNMlIiJyRInwGjtEREQucKRLRETkCDtdIiIiR9jpEhEROcJOl4iIyBF2ukRERI6w0yUiInKEnS4REZEj7HSJiIgcYadLRETkCDtdIiIiR9jpEhEROcJOl4iIyBF2ukRERI6w0yUiInKEnS4REZEj7HSJiIgcYadLRETkCDtdIiIiR9jpEhEROcJOl4iIyBF2ukRERI6w0yUiInKEnS4REZEj/wWWo0I2ztsQ+wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16]\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(mnist.test.labels[idx],\n",
    "                                                  order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
